package com.tinyshardingjdbc.tinyshardingjdbc.shardingasync.tool;

import java.beans.PropertyEditorSupport;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 类描述：时间操作定义类
 */
public class DateUtils extends PropertyEditorSupport {
    // 各种时间格式
    public static final SimpleDateFormat date_sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 各种时间格式
    public static final SimpleDateFormat yyyyMMddHH = new SimpleDateFormat("yyyyMMddHH");
    public static final SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
    public static final SimpleDateFormat yyyyMM = new SimpleDateFormat("yyyyMM");
    public static final SimpleDateFormat HHmm = new SimpleDateFormat("HHmm");
    public static final SimpleDateFormat HHmmssSSSS = new SimpleDateFormat("HH:mm:ssSSSS");
    public static final SimpleDateFormat yymmddhhmmsssss = new SimpleDateFormat("yyMMddHHmmssSSS");
    // 各种时间格式
    public static final SimpleDateFormat date_sdf_wz = new SimpleDateFormat("yyyy年MM月dd日");
    public static final SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    public static final SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
    public static final SimpleDateFormat short_time_sdf = new SimpleDateFormat("HH:mm");
    public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 以毫秒表示的时间
    private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
    private static final long HOUR_IN_MILLIS = 3600 * 1000;
    private static final long MINUTE_IN_MILLIS = 60 * 1000;
    private static final long SECOND_IN_MILLIS = 1000;

    // 指定模式的时间格式
    private static SimpleDateFormat getSDFormat(String pattern) {
        return new SimpleDateFormat(pattern);
    }

    /**
     * 当前日历，这里用中国时间表示
     *
     * @return 以当地时区表示的系统当前日历
     */
    public static Calendar getCalendar() {
        return Calendar.getInstance();
    }

    /**
     * 指定毫秒数表示的日历
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日历
     */
    public static Calendar getCalendar(long millis) {
        Calendar cal = Calendar.getInstance();
        // --------------------cal.setTimeInMillis(millis);
        cal.setTime(new Date(millis));
        return cal;
    }

    public static Calendar getCalendar(Date data) {
        Calendar cal = Calendar.getInstance();
        // --------------------cal.setTimeInMillis(millis);
        cal.setTime(data);
        return cal;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getDate
    // 各种方式获取的Date
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 当前日期
     *
     * @return 系统当前时间
     */
    public static Date getDate() {
        return new Date();
    }

    /**
     * 指定毫秒数表示的日期
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日期
     */
    public static Date getDate(long millis) {
        return new Date(millis);
    }

    /**
     * 时间戳转换为字符串
     *
     * @param time
     * @return
     */
    public static String timestamptoStr(Timestamp time) {
        Date date = null;
        if (null != time) {
            date = new Date(time.getTime());
        }
        return date2Str(date_sdf);
    }

    /**
     * 字符串转换时间戳
     *
     * @param str
     * @return
     */
    public static Timestamp str2Timestamp(String str) {
        Date date = str2Date(str, date_sdf);
        return new Timestamp(date.getTime());
    }

    /**
     * 字符串转换成日期
     *
     * @param str
     * @param sdf
     * @return
     */
    public static Date str2Date(String str, SimpleDateFormat sdf) {
        if (null == str || "".equals(str)) {
            return null;
        }
        Date date = null;
        try {
            date = sdf.parse(str);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期转换为字符串
     *
     * @param date_sdf 日期格式
     * @return 字符串
     */
    public static String date2Str(SimpleDateFormat date_sdf) {
        Date date = getDate();
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 格式化时间
     *
     * @param date
     * @param format
     * @return
     */
    public static String dateformat(String date, String format) {
        SimpleDateFormat sformat = new SimpleDateFormat(format);
        Date _date = null;
        try {
            _date = sformat.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return sformat.format(_date);
    }

    /**
     * 格式化时间
     *
     * @param date
     * @return
     */
    public static String strToDateFormat(String date, String patternTag) {
        try {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
            formatter.setLenient(false);
            Date newDate = formatter.parse(date);
            formatter = new SimpleDateFormat(patternTag);
            return formatter.format(newDate);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期转换为字符串
     *
     * @param date     日期
     * @param date_sdf 日期格式
     * @return 字符串
     */
    public static String date2Str(Date date, SimpleDateFormat date_sdf) {
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 日期转换为字符串
     *
     * @param
     * @param format 日期格式
     * @return 字符串
     */
    public static String getDate(String format) {
        Date date = new Date();
        if (null == date) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 指定毫秒数的时间戳
     *
     * @param millis 毫秒数
     * @return 指定毫秒数的时间戳
     */
    public static Timestamp getTimestamp(long millis) {
        return new Timestamp(millis);
    }

    /**
     * 以字符形式表示的时间戳
     *
     * @param time 毫秒数
     * @return 以字符形式表示的时间戳
     */
    public static Timestamp getTimestamp(String time) {
        return new Timestamp(Long.parseLong(time));
    }

    /**
     * 系统当前的时间戳
     *
     * @return 系统当前的时间戳
     */
    public static Timestamp getTimestamp() {
        return new Timestamp(System.currentTimeMillis());
    }

    /**
     * 当前时间，格式 yyyy-MM-dd HH:mm:ss
     *
     * @return 当前时间的标准形式字符串
     */
    public static String now() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 指定日期的时间戳
     *
     * @param date 指定日期
     * @return 指定日期的时间戳
     */
    public static Timestamp getTimestamp(Date date) {
        return new Timestamp(date.getTime());
    }

    /**
     * 指定日历的时间戳
     *
     * @param cal 指定日历
     * @return 指定日历的时间戳
     */
    public static Timestamp getCalendarTimestamp(Calendar cal) {
        // ---------------------return new Timestamp(cal.getTimeInMillis());
        return new Timestamp(cal.getTime().getTime());
    }

    public static Timestamp gettimestamp() {
        Date dt = new Date();
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = df.format(dt);
        Timestamp buydate = Timestamp.valueOf(nowTime);
        return buydate;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getMillis
    // 各种方式获取的Millis
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 系统时间的毫秒数
     *
     * @return 系统时间的毫秒数
     */
    public static long getMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 指定日历的毫秒数
     *
     * @param cal 指定日历
     * @return 指定日历的毫秒数
     */
    public static long getMillis(Calendar cal) {
        // --------------------return cal.getTimeInMillis();
        return cal.getTime().getTime();
    }

    /**
     * 指定日期的毫秒数
     *
     * @param date 指定日期
     * @return 指定日期的毫秒数
     */
    public static long getMillis(Date date) {
        return date.getTime();
    }

    /**
     * 指定时间戳的毫秒数
     *
     * @param ts 指定时间戳
     * @return 指定时间戳的毫秒数
     */
    public static long getMillis(Timestamp ts) {
        return ts.getTime();
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatDate
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日
     *
     * @return 默认日期按“年-月-日“格式显示
     */
    public static String formatDate() {
        return date_sdf.format(getCalendar().getTime());
    }

    /**
     * 默认方式表示的系统当前日期，具体格式：yyyy-MM-dd HH:mm:ss
     *
     * @return 默认日期按“yyyy-MM-dd HH:mm:ss“格式显示
     */
    public static String formatDateTime() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 获取时间字符串
     */
    public static String getDataString(SimpleDateFormat formatstr) {
        return formatstr.format(getCalendar().getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Calendar cal) {
        return date_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Date date) {
        return date_sdf.format(date);
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日“格式显示
     */
    public static String formatDate(long millis) {
        return date_sdf.format(new Date(millis));
    }

    /**
     * 默认日期按指定格式显示
     *
     * @param pattern 指定的格式
     * @return 默认日期按指定格式显示
     */
    public static String formatDate(String pattern) {
        return getSDFormat(pattern).format(getCalendar().getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param cal     指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Calendar cal, String pattern) {
        return getSDFormat(pattern).format(cal.getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param date    指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Date date, String pattern) {
        return getSDFormat(pattern).format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日 时：分
     *
     * @return 默认日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime() {
        return time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(long millis) {
        return time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Calendar cal) {
        return time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Date date) {
        return time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatShortTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：时：分
     *
     * @return 默认日期按“时：分“格式显示
     */
    public static String formatShortTime() {
        return short_time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“时：分“格式显示
     */
    public static String formatShortTime(long millis) {
        return short_time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Calendar cal) {
        return short_time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Date date) {
        return short_time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // parseDate
    // parseCalendar
    // parseTimestamp
    // 将字符串按照一定的格式转化为日期或时间
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     * @throws
     */
    public static Date parseDate(String src, String pattern) throws ParseException {
        return getSDFormat(pattern).parse(src);

    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     * @throws
     */
    public static Calendar parseCalendar(String src, String pattern) throws ParseException {

        Date date = parseDate(src, pattern);
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal;
    }

    public static String formatAddDate(String src, String pattern, int amount) throws ParseException {
        Calendar cal;
        cal = parseCalendar(src, pattern);
        cal.add(Calendar.DATE, amount);
        return formatDate(cal);
    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的时间戳
     * @throws ParseException
     * @throws
     */
    public static Timestamp parseTimestamp(String src, String pattern) throws ParseException {
        Date date = parseDate(src, pattern);
        return new Timestamp(date.getTime());
    }

    // ////////////////////////////////////////////////////////////////////////////
    // dateDiff
    // 计算两个日期之间的差值
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 计算两个时间之间的差值，根据标志的不同而不同
     *
     * @param flag   计算标志，表示按照年/月/日/时/分/秒等计算
     * @param calSrc 减数
     * @param calDes 被减数
     * @return 两个日期之间的差值
     */
    public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

        long millisDiff = getMillis(calSrc) - getMillis(calDes);

        if (flag == 'y') {
            return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
        }

        if (flag == 'd') {
            return (int) (millisDiff / DAY_IN_MILLIS);
        }

        if (flag == 'h') {
            return (int) (millisDiff / HOUR_IN_MILLIS);
        }

        if (flag == 'm') {
            return (int) (millisDiff / MINUTE_IN_MILLIS);
        }

        if (flag == 's') {
            return (int) (millisDiff / SECOND_IN_MILLIS);
        }

        return 0;
    }

    public static int dateDiff(String flag, Calendar calSrc, Calendar calDes) {

        long millisDiff = getMillis(calSrc) - getMillis(calDes);

        if ("y".equals(flag)) {
            return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
        }

        if ("d".equals(flag)) {
            return (int) (millisDiff / DAY_IN_MILLIS);
        }

        if ("h".equals(flag)) {
            return (int) (millisDiff / HOUR_IN_MILLIS);
        }

        if ("m".equals(flag)) {
            return (int) (millisDiff / MINUTE_IN_MILLIS);
        }

        if ("s".equals(flag)) {
            return (int) (millisDiff / SECOND_IN_MILLIS);
        }

        return 0;
    }

    public static int dayBetween(String date1, String date2) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(sdf.parse(date1));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Long time1 = cal.getTimeInMillis();
        try {
            cal.setTime(sdf.parse(date2));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Long time2 = cal.getTimeInMillis();
        Long between_days = (time2 - time1) / (1000 * 60 * 60 * 24);
        return Integer.parseInt(String.valueOf(between_days));
    }

    /**
     * 获取当前时间的年份
     *
     * @return
     */
    public static int getYear() {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(getDate());
        return calendar.get(Calendar.YEAR);
    }

    /**
     * 获取当前时间的年份
     *
     * @return
     */
    public static int getMonth() {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(getDate());
        return calendar.get(Calendar.MONTH) + 1;
    }

    /**
     * 获取当前时间的年份
     *
     * @return
     */
    public static int getYear(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }

    /**
     * 获取当前时间的年月
     *
     * @return
     */
    public static int getYearAndMonth(Date date) {

        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }

    public static Date stringToDate(String dateString, String format) {

        Date result = null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            result = sdf.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 获取当前时间的下个月一号
     * <p>Title: DateFormatUtil.java</p>
     *
     * @author zrp
     * @date 2018年7月23日
     * @version 1.0
     * @parameter
     */
    public static String nextMonthFirstDate(String strDate, String pattern, int amount) {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date date = null;
        try {
            if (ConvertUtils.isEmpty(strDate)) {
                date = new Date();
            } else {
                date = sdf.parse(strDate);
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        calendar.set(Calendar.DAY_OF_MONTH, amount);
        calendar.add(Calendar.MONTH, amount);
        sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(calendar.getTime());
    }

    /**
     * 获取当前时间的下季度初
     * <p>Title: DateFormatUtil.java</p>
     *
     * @author zrp
     * @date 2018年7月23日
     * @version 1.0
     * @parameter
     */
    public static String nextJdFirstDate(String strDate, String pattern, int amount) {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date date = null;
        try {
            if (ConvertUtils.isEmpty(strDate)) {
                date = new Date();
            } else {
                date = sdf.parse(strDate);
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int month = getQuarterInMonth(strDate, pattern);
        calendar.add(Calendar.MONTH, month);
        calendar.set(Calendar.DAY_OF_MONTH, amount);
        sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(calendar.getTime());
    }

    /**
     * 获取下年第一天
     *
     * @return
     */
    public static String getYearFirstDay(String strDate) {
        String year = dateformat(strDate, "yyyy");
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, Integer.parseInt(year) + 1);
        calendar.roll(Calendar.DAY_OF_YEAR, 0);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(calendar.getTime());
    }

    private static int getQuarterInMonth(String strDate, String pattern) {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date date = null;
        try {
            if (ConvertUtils.isEmpty(strDate)) {
                date = new Date();
            } else {
                date = sdf.parse(strDate);
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MM");
        String month = simpleDateFormat.format(date);
        if (month.equals("01") || month.equals("04") || month.equals("07") || month.equals("10")) {
            return 3;
        } else if (month.equals("02") || month.equals("05") || month.equals("08") || month.equals("11")) {
            return 2;
        } else if (month.equals("03") || month.equals("06") || month.equals("09") || month.equals("12")) {
            return 1;
        }
        return 0;
    }

    /**
     * 获取当前时间往前往后n的日期
     * eg: date ==null 默认是系统当前时间  否则以date为时间起点
     * n > 0 往后
     * n = 0 当前时间
     * n < 0 往前
     *
     * @param date
     * @param n
     * @return
     */
    public static List<String> getBaDateList(Date date, int n, String pattern) {
        List<String> list = new ArrayList<>();
        Calendar c = Calendar.getInstance();
        Date today = new Date();
        if (null != date) {
            today = date;
        }
        if (ConvertUtils.isEmpty(pattern)) {
            pattern = "yyyyMMdd";
        }
        c.setTime(today);
        if (n > 0) {
            for (int i = 0; i <= n; i++) {
                c.add(Calendar.DATE, i);
                list.add(new SimpleDateFormat(pattern).format(c.getTime()));
                c.setTime(today);
            }
        } else if (n < 0) {
            for (int i = n; i <= 0; i++) {
                c.add(Calendar.DATE, i);
                list.add(new SimpleDateFormat(pattern).format(c.getTime()));
                c.setTime(today);
            }
        } else {
            c.add(Calendar.DATE, 0);
            list.add(new SimpleDateFormat(pattern).format(c.getTime()));
            c.setTime(today);
        }
        return list;
    }

    public static List<String> getBaMonthList(Date date, int n, String pattern) {
        List<String> list = new ArrayList<>();
        Calendar c = Calendar.getInstance();
        Date today = new Date();
        if (null != date) {
            today = date;
        }
        if (ConvertUtils.isEmpty(pattern)) {
            pattern = "yyyyMM";
        }
        c.setTime(today);
        if (n > 0) {
            for (int i = 0; i <= n; i++) {
                c.add(Calendar.MONTH, i);
                list.add(new SimpleDateFormat(pattern).format(c.getTime()));
                c.setTime(today);
            }
        } else if (n < 0) {
            for (int i = n; i <= 0; i++) {
                c.add(Calendar.MONTH, i);
                list.add(new SimpleDateFormat(pattern).format(c.getTime()));
                c.setTime(today);
            }
        } else {
            c.add(Calendar.MONTH, 0);
            list.add(new SimpleDateFormat(pattern).format(c.getTime()));
            c.setTime(today);
        }
        return list;
    }

    public static String getBaDate(Date date, int n, String pattern) {
        Calendar c = Calendar.getInstance();
        Date today = new Date();
        if (null != date) {
            today = date;
        }
        if (ConvertUtils.isEmpty(pattern)) {
            pattern = "yyyyMMdd";
        }
        c.setTime(today);
        c.add(Calendar.DATE, n);
        return new SimpleDateFormat(pattern).format(c.getTime());

    }

    /**
     * @param dateStr
     * @param n
     * @param pattern
     * @return
     */
    public static String getBaDateByDateStr(String dateStr, int n, String pattern, String unit) {
        Calendar c = Calendar.getInstance();
        Date today = new Date();
        if (!ConvertUtils.isEmpty(dateStr)) {
            today = str2Date(dateStr, datetimeFormat);
        }
        if (ConvertUtils.isEmpty(pattern)) {
            pattern = "yyyyMMdd";
        }
        c.setTime(today);
        if ("date".equals(unit)) {
            c.add(Calendar.DATE, n);
        } else if ("second".equals(unit)) {
            c.add(Calendar.SECOND, n);
        } else if ("hour".equals(unit)) {
            c.add(Calendar.HOUR, n);
        } else if ("minute".equals(unit)) {
            c.add(Calendar.MINUTE, n);
        } else if ("month".equals(unit)) {
            c.add(Calendar.MONTH, n);
        }

        return new SimpleDateFormat(pattern).format(c.getTime());

    }

    /**
     * @description 获得指定日期的开始时间
     * @author: yinbangyong
     * @Date: 2020/7/8
     */
    public static Date getDayStartTime(Date date) {
        try {
            date = date_sdf.parse(date_sdf.format(date));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取过去7天内的日期数组
     *
     * @return 日期数组
     */
    public static ArrayList<String> pastDay(String time) {
        ArrayList<String> pastDaysList = new ArrayList<>();
        try {
            //我这里传来的时间是个string类型的，所以要先转为date类型的。
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse(time);
            for (int i = 6; i >= 0; i--) {
                pastDaysList.add(getPastDate(i, date));
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return pastDaysList;
    }

    /**
     * 获取过去第几天的日期
     *
     * @param past
     * @return
     */
    public static String getPastDate(int past, Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - past);
        Date today = calendar.getTime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String result = sdf.format(today);
        return result;
    }

    /**
     * @description 获得指定日期的结束时间
     * @author: yinbangyong
     * @Date: 2020/7/8
     */
    public static Date getDayEndTime(Date date) {
        try {
            date = datetimeFormat.parse(date_sdf.format(date) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获得本天的开始时间
     *
     * @return
     */
    public static String getCurrentDayStartTime() {
        Date now = new Date();
        try {
            now = date_sdf.parse(date_sdf.format(now));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 获得本天的结束时间
     *
     * @return
     */
    public static String getCurrentDayEndTime() {
        Date now = new Date();
        try {
            now = datetimeFormat.parse(date_sdf.format(now) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 获得本月的开始时间
     *
     * @return
     */
    public static String getCurrentMonthStartTime(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        try {
            c.set(Calendar.DATE, 1);
            now = date_sdf.parse(date_sdf.format(c.getTime()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 获得本月的开始时间
     *
     * @return
     */
    public static String getNowMonthStartYMDHS(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        try {
            c.set(Calendar.DATE, 1);
            now = yyyymmddhhmmss.parse(yyyymmddhhmmss.format(c.getTime()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 本月的结束时间
     *
     * @return
     */
    public static String getNowMonthEndYMDHS(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        try {
            c.set(Calendar.DATE, 1);
            c.add(Calendar.MONTH, 1);
            c.add(Calendar.DATE, -1);
            String format = date_sdf.format(c.getTime());
            now = datetimeFormat.parse(format + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 本月的结束时间
     *
     * @return
     */
    public static String getCurrentMonthEndTime(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        try {
            c.set(Calendar.DATE, 1);
            c.add(Calendar.MONTH, 1);
            c.add(Calendar.DATE, -1);
            now = datetimeFormat.parse(date_sdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 当前季度的开始时间
     *
     * @return
     */
    public static String getCurrentQuarterStartTime(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        int currentMonth = c.get(Calendar.MONTH) + 1;
        try {
            if (currentMonth >= 1 && currentMonth <= 3)
                c.set(Calendar.MONTH, 0);
            else if (currentMonth >= 4 && currentMonth <= 6)
                c.set(Calendar.MONTH, 3);
            else if (currentMonth >= 7 && currentMonth <= 9)
                c.set(Calendar.MONTH, 4);
            else if (currentMonth >= 10 && currentMonth <= 12)
                c.set(Calendar.MONTH, 9);
            c.set(Calendar.DATE, 1);
            now = datetimeFormat.parse(date_sdf.format(c.getTime()) + " 00:00:00");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 当前季度的结束时间
     *
     * @return
     */
    public static String getCurrentQuarterEndTime(Date now) {
        Calendar c = Calendar.getInstance();
        if (now == null) {
            now = new Date();
        }
        c.setTime(now);
        int currentMonth = c.get(Calendar.MONTH) + 1;
        try {
            if (currentMonth >= 1 && currentMonth <= 3) {
                c.set(Calendar.MONTH, 2);
                c.set(Calendar.DATE, 31);
            } else if (currentMonth >= 4 && currentMonth <= 6) {
                c.set(Calendar.MONTH, 5);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 7 && currentMonth <= 9) {
                c.set(Calendar.MONTH, 8);
                c.set(Calendar.DATE, 30);
            } else if (currentMonth >= 10 && currentMonth <= 12) {
                c.set(Calendar.MONTH, 11);
                c.set(Calendar.DATE, 31);
            }
            now = datetimeFormat.parse(date_sdf.format(c.getTime()) + " 23:59:59");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return datetimeFormat.format(now);
    }

    /**
     * 时间戳字符串转时间字符串
     * <p>Title: DateUtils.java</p>
     *
     * @author zrp
     * @date 2020年3月3日
     * @version 1.0
     * @parameter
     */
    public static String timeStamp2DateStr(String seconds, String format) {
        if (ConvertUtils.isEmpty(seconds)) {
            return "";
        }
        if (seconds.length() > 10) {
            seconds = seconds.substring(0, 10);
        }
        if (ConvertUtils.isEmpty(format)) {
            format = "yyyy-MM-dd HH:mm:ss";
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(new Date(Long.valueOf(seconds + "000")));
    }

    /**
     * 指定日期加几天后的日期
     *
     * @param day 加几天，负数表示减几天
     * @return
     */
    public static Date getAddDate(Date date, int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) + day);
        Date today = calendar.getTime();
        return today;
    }

    /**
     * 指定日期加几天后的日期
     *
     * @param minute 加分钟 减分钟
     * @return
     */
    public static Date getAddDateBy(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.MINUTE, calendar.get(Calendar.MINUTE) + minute);
        Date today = calendar.getTime();
        return today;
    }

    /**
     * 获取两个日期之间的所有月份
     *
     * @param minDate
     * @param maxDate
     * @return [2020-01, 2020-02, 2020-03]
     * @throws ParseException
     */
    public static List<String> getMonthBetween(String minDate, String maxDate) {
        try {
            ArrayList<String> result = new ArrayList<String>();
            // 格式化为年月
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");

            Calendar min = Calendar.getInstance();
            Calendar max = Calendar.getInstance();

            min.setTime(sdf.parse(minDate));
            min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

            max.setTime(sdf.parse(maxDate));
            max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

            Calendar curr = min;
            while (curr.before(max)) {
                result.add(sdf.format(curr.getTime()));
                curr.add(Calendar.MONTH, 1);
            }

            return result;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取两个日期之间的所有月份
     *
     * @param minDate
     * @param maxDate
     * @return [2020-01, 2020-02, 2020-03]
     * @throws ParseException
     */
    public static List<String> getMonthBetweenFormat(String minDate, String maxDate, String format) {
        try {
            ArrayList<String> result = new ArrayList<String>();
            // 格式化为年月
            SimpleDateFormat sdf = new SimpleDateFormat(format);

            Calendar min = Calendar.getInstance();
            Calendar max = Calendar.getInstance();

            min.setTime(sdf.parse(minDate));
            min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

            max.setTime(sdf.parse(maxDate));
            max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

            Calendar curr = min;
            while (curr.before(max)) {
                result.add(sdf.format(curr.getTime()));
                curr.add(Calendar.MONTH, 1);
            }

            return result;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static int dateDiff(String flag, String startTime, String endTime) {
        try {
            Calendar calStart = parseCalendar(startTime, "yyyy-MM-dd HH:mm:ss");
            Calendar calEnd = parseCalendar(endTime, "yyyy-MM-dd HH:mm:ss");

            long millisDiff = getMillis(calEnd) - getMillis(calStart);

            if ("year".equals(flag)) {
                return (calStart.get(calStart.YEAR) - calStart.get(calStart.YEAR));
            }

            if ("day".equals(flag)) {
                return (int) (millisDiff / DAY_IN_MILLIS);
            }

            if ("hour".equals(flag)) {
                return (int) (millisDiff / HOUR_IN_MILLIS);
            }

            if ("minute".equals(flag)) {
                return (int) (millisDiff / MINUTE_IN_MILLIS);
            }

            if ("second".equals(flag)) {
                return (int) (millisDiff / SECOND_IN_MILLIS);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 获取本周开始结束时间
     *
     * @param date
     * @return
     */
    public static String getTimeInterval(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // System.out.println("要计算日期为:" + sdf.format(cal.getTime())); // 输出要计算日期
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        String imptimeBegin = sdf.format(cal.getTime());
        // System.out.println("所在周星期一的日期：" + imptimeBegin);
        cal.add(Calendar.DATE, 6);
        String imptimeEnd = sdf.format(cal.getTime());
        // System.out.println("所在周星期日的日期：" + imptimeEnd);
        return imptimeBegin + "," + imptimeEnd;
    }

    /**
     * 获取上周开始结束日期
     *
     * @return
     */
    public static String getLastTimeInterval() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        int dayOfWeek = calendar1.get(Calendar.DAY_OF_WEEK) - 1;
        int offset1 = 1 - dayOfWeek;
        int offset2 = 7 - dayOfWeek;
        calendar1.add(Calendar.DATE, offset1 - 7);
        calendar2.add(Calendar.DATE, offset2 - 7);
        String lastBeginDate = sdf.format(calendar1.getTime());
        String lastEndDate = sdf.format(calendar2.getTime());
        return lastBeginDate + "," + lastEndDate;
    }

    public static void main(String[] args) {
        String ss = "20200203164101";
        System.out.println(getBaDateByDateStr("2020-02-08 23:47:34", -6048000, "yyyy-MM-dd HH:mm:ss", "second"));
        System.out.println(dateDiff("s", getCalendar(), getCalendar(str2Date(ss, yyyymmddhhmmss))));
        System.out.println(timeStamp2DateStr("1583164669000", "yyyy-MM-dd HH:mm:ss"));
        String sss = "";
		/*System.out.println(oConvertUtils.isEmpty(sss)?"2":"1");
		Date transTime = DateUtils.str2Date("2020-06-21 09:39:26",DateUtils.datetimeFormat);
		System.out.println(formatDate(transTime,"yyyyMMdd"));
		Date transTime1 = DateUtils.str2Date("20200522 093926",DateUtils.datetimeFormat);
		String tradeDate = DateUtils.formatDate(transTime1,"yyyyMMdd");
		String tradeTime = DateUtils.formatDate(transTime1,"HHmmss");
		System.out.println(tradeDate);*/
        System.out.println(strToDateFormat("20200610", "yyyy-MM"));

        String str = "";
        System.out.println(ConvertUtils.isEmpty(str) ? "22" : "33");
    }

    /**
     * 获取昨天日期
     */
    public static String getYesterday() {
        Date today = new Date(System.currentTimeMillis() - 1000 * 60 * 60 * 24);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String yesterday = simpleDateFormat.format(today);
        return yesterday;
    }

    /**
     * 获取昨天日期
     */
    public static String getBeforDay(int i) {
        Date today = new Date(System.currentTimeMillis() - 1000 * 60 * 60 * 24 * i);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String yesterday = simpleDateFormat.format(today);
        return yesterday;
    }

    /**
     * 获取两个日期之间的所有日期(字符串格式, 按天计算)
     *
     * @param startTime String 开始时间 yyyy-MM-dd
     * @param endTime   String 结束时间 yyyy-MM-dd
     * @return
     */
    public static List<String> getBetweenDays(String startTime, String endTime) {

        try {
            //1、定义转换格式
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");

            Date start = df.parse(startTime);
            Date end = df.parse(endTime);

            List<String> result = new ArrayList<String>();

            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);

            tempStart.add(Calendar.DAY_OF_YEAR, 1);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            result.add(sdf.format(start));
            while (tempStart.before(tempEnd)) {
                result.add(sdf.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }
            result.add(endTime);
            return result;
        } catch (Exception e) {


        }
        return null;
    }

    public static String getLastMonth(String yearMonth) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyyMM");
            Date date = format.parse(yearMonth);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date); // 设置为当前时间
            calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1); // 设置为上一个月
            date = calendar.getTime();
            String accDate = format.format(date);
            return accDate;
        } catch (Exception e) {

        }
        return null;
    }

    public static String getLastMonth(String yearMonth, Integer i) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyyMM");
            Date date = format.parse(yearMonth);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date); // 设置为当前时间
            calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - i); // 设置为上一个月
            date = calendar.getTime();
            String accDate = format.format(date);
            return accDate;
        } catch (Exception e) {

        }
        return null;
    }

    public static String getnextMonth(String yearMonth) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyyMM");
            Date date = format.parse(yearMonth);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date); // 设置为当前时间
            calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 1); // 设置为上一个月
            date = calendar.getTime();
            String accDate = format.format(date);
            return accDate;
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 获取两个日期之间的所有月份
     *
     * @param minDate
     * @param maxDate
     * @return [2020-01, 2020-02, 2020-03]
     * @throws ParseException
     */
    public static List<String> getMonthBetweenYYYYMM(String minDate, String maxDate) {
        try {
            ArrayList<String> result = new ArrayList<String>();
            // 格式化为年月
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");

            Calendar min = Calendar.getInstance();
            Calendar max = Calendar.getInstance();

            min.setTime(sdf.parse(minDate));
            min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

            max.setTime(sdf.parse(maxDate));
            max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

            Calendar curr = min;
            while (curr.before(max)) {
                result.add(sdf.format(curr.getTime()));
                curr.add(Calendar.MONTH, 1);
            }

            return result;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取时间区间月份
     *
     * @param startDate
     * @param endDate
     * @return
     * @throws Exception
     */
    public static List<String> calAllMonths(String startDate, String endDate) {
        try {
            SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            SimpleDateFormat month_sdf = new SimpleDateFormat("yyyyMM");
            List<String> months = new ArrayList<>();
            if (startDate.length() == 10) {
                startDate = startDate + " 00:00:00";
            }
            if (endDate.length() == 10) {
                endDate = endDate + " 23:59:59";
            }
            Date start = time_sdf.parse(startDate);
            Date end = time_sdf.parse(endDate);
            while (start.compareTo(end) <= 0) {
                months.add(month_sdf.format(start));
                start = org.apache.commons.lang3.time.DateUtils.addMonths(start, 1);
            }
            months.add(month_sdf.format(end));
            //去重
            List<String> respMonths = months.stream().distinct().sorted(Comparator.comparing(String::toString).reversed()).collect(Collectors.toList());
            return respMonths;
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd
     * HH:mm:ss“ * @param text String类型的时间值
     */
    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        if (ConvertUtils.isEmpty(text)) {
            try {
                if (text.indexOf(":") == -1 && text.length() == 10) {
                    setValue(this.date_sdf.parse(text));
                } else if (text.indexOf(":") > 0 && text.length() == 19) {
                    setValue(this.datetimeFormat.parse(text));
                } else {
                    throw new IllegalArgumentException("Could not parse date, date format is error ");
                }
            } catch (ParseException ex) {
                IllegalArgumentException iae = new IllegalArgumentException("Could not parse date: " + ex.getMessage());
                iae.initCause(ex);
                throw iae;
            }
        } else {
            setValue(null);
        }
    }


}
